// app.js
// 定义全局配置对象，确保在任何地方都能访问
const GLOBAL_CONFIG = {
  // 云开发环境配置
  cloud: {
    env: 'prod-0gjrhbe3985f006d', // 云开发环境ID
    traceUser: true, // 是否记录用户访问日志
  },

  // wx23e0e9a106ed0fb7 prod-0gjrhbe3985f006d tid=1045903 rid=multi_tenant_1uwb082FIjrmG4 robot-vbat bid=2600029822 robot-vbat-002

  // 云托管配置
  container: {
    env: 'prod-0gjrhbe3985f006d',
    service: 'robot-vbat', // 云托管服务名称
    appid: 'wx23e0e9a106ed0fb7',
    tid: '1045903',
    rid: 'multi_tenant_1uwb082FIjrmG4',
    bid: '2600029822',
    instance: 'robot-vbat-002',
    projectName: 'robot-vbat'
  },
  
  // 环境配置
  environment: {
    // 测试环境配置 - 仅用于本地测试，生产环境请设置为false
    testMode: false, // 设置为false使用云托管的wss协议连接
  },
  
  // 获取云托管 API 基础路径
  get apiBaseUrl() {
    return 'https://robot-prod-0gjrhbe3985f006d-1377593453.ap-shanghai.run.wxcloudrun.com';
  },
  
  // 获取WebSocket URL
  get websocketUrl() {
    if (this.environment.testMode) {
      return 'ws://localhost:80';
    }
    return 'wss://tcb-ws.tencentcloudapi.com';
  }
};

App({
  onLaunch: function () {
    // 小程序启动时执行的逻辑
    console.log('VBAT小程序启动');
    
    // 初始化云开发环境
    wx.cloud.init({
      env: GLOBAL_CONFIG.cloud.env, // 云开发环境ID
      traceUser: GLOBAL_CONFIG.cloud.traceUser, // 是否记录用户访问日志
    });
    
    // 输出当前配置信息
    this.logConfig();
    
    // 验证云托管服务连接
    this.testCloudHostingConnection();
    
    // 从小程序启动时获取云托管服务的配置信息
    this.fetchCloudHostingConfig();
  },
  
  // 从小程序获取云托管服务的配置信息
  fetchCloudHostingConfig: function() {
    console.log('开始获取云托管服务配置');
    
    wx.cloud.callContainer({
      "config": {
        "env": GLOBAL_CONFIG.container.env
      },
      "path": "/api/config",
      "header": {
        "X-WX-SERVICE": GLOBAL_CONFIG.container.service,
        "content-type": "application/json"
      },
      "method": "GET",
      success: (res) => {
        console.log('云托管配置获取成功:', res);
        if (res.statusCode === 200 && res.data && res.data.status === 'ok' && res.data.config) {
          // 保存获取到的配置信息
          this.globalData.cloudHostingConfig = res.data.config;
          
          // 记录配置信息
          console.log('云托管配置详情:', {
            voltageThresholds: {
              lower: res.data.config.VOLTAGE_THRESHOLDS.lower,
              upper: res.data.config.VOLTAGE_THRESHOLDS.upper
            },
            systemConfig: {
              alertCooldown: res.data.config.SYSTEM_CONFIG.ALERT_COOLDOWN_TIME,
              maxHistorySize: res.data.config.SYSTEM_CONFIG.maxHistorySize
            },
            hasDingtalkWebhook: res.data.config.DINGTALK_ROBOT.hasWebhook,
            dingtalkKeywords: res.data.config.DINGTALK_ROBOT.keywords
          });
        }
      },
      fail: (error) => {
        console.error('云托管配置获取失败:', error);
      },
      complete: () => {
        console.log('云托管配置获取操作完成');
      }
    });
  },
  
  // 测试云托管服务连接 - HTTP调用方式
  testCloudHostingConnection: function() {
    wx.cloud.callContainer({
      "config": {
        "env": GLOBAL_CONFIG.container.env
      },
      "path": "/api/count",
      "header": {
        "X-WX-SERVICE": GLOBAL_CONFIG.container.service,
        "content-type": "application/json"
      },
      "method": "POST",
      "data": {
        "action": "inc"
      },
      success: (res) => {
        console.log('云托管服务连接成功:', res);
      },
      fail: (error) => {
        console.error('云托管服务连接失败:', error);
      }
    });
  },
  
  // 使用新的wx.cloud.connectContainer方法连接云托管WebSocket服务
  connectContainerWebSocket: async function(connectOptions = {}) {
    try {
      // 设置连接超时
      const timeout = connectOptions.timeout || 10000; // 默认10秒超时
      
      // 创建超时Promise
      const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => reject(new Error('连接超时: 云托管服务响应缓慢')), timeout);
      });
      
      // 开始连接计时
      const startTime = Date.now();
      console.log(`开始连接云托管WebSocket服务，超时时间: ${timeout}ms`);
      
      // 使用Promise.race处理连接超时
      const { socketTask } = await Promise.race([
        wx.cloud.connectContainer({
          "config": {
            "env": GLOBAL_CONFIG.container.env
          },
          "service": GLOBAL_CONFIG.container.service,
          "path": "/"
        }),
        timeoutPromise
      ]);
      
      const connectTime = Date.now() - startTime;
      console.log(`云托管WebSocket服务连接建立成功，耗时: ${connectTime}ms`);
      
      // 设置消息接收处理
      socketTask.onMessage(function (res) {
        console.log('收到云托管WebSocket消息:', res.data);
        // 通知监听器有新消息
        if (connectOptions.onMessage) {
          connectOptions.onMessage(res);
        }
      });
      
      // 设置连接打开处理
      socketTask.onOpen(function (res) {
        console.log('成功连接到云托管WebSocket服务器');
        // 连接成功后发送测试消息
        socketTask.send({ data: '' });
        // 通知监听器连接已打开
        if (connectOptions.onOpen) {
          connectOptions.onOpen(res);
        }
      });
      
      // 设置连接关闭处理
      socketTask.onClose(function (res) {
        console.log('云托管WebSocket连接已断开', res);
        // 通知监听器连接已关闭
        if (connectOptions.onClose) {
          connectOptions.onClose(res);
        }
      });
      
      // 设置错误处理
      socketTask.onError(function (res) {
        console.error('云托管WebSocket连接发生错误:', res);
        // 通知监听器连接发生错误
        if (connectOptions.onError) {
          connectOptions.onError(res);
        }
      });
      
      // 保存socketTask引用供全局使用
      this.globalData.containerSocketTask = socketTask;
      return socketTask;
    } catch (error) {
      console.error('连接云托管WebSocket服务失败:', error);
      // 通知监听器连接失败
      if (connectOptions.onError) {
        connectOptions.onError(error);
      }
      return null;
    }
  },
  
  globalData: {
    // 全局数据
    version: 'v0.2.0',
    
    // 集中化配置管理 - 只需修改此部分即可更新所有环境和服务参数
    // 直接引用全局配置对象
    CONFIG: GLOBAL_CONFIG,
    
    // 云开发配置（保持向后兼容）
    cloudConfig: {
      get env() { return GLOBAL_CONFIG.container.env; },
      get service() { return GLOBAL_CONFIG.container.service; },
      get apiBaseUrl() { return GLOBAL_CONFIG.apiBaseUrl; },
      get websocketUrl() { return GLOBAL_CONFIG.websocketUrl; },
      get testWebsocketUrl() { return 'ws://localhost:80'; },
      get appid() { return GLOBAL_CONFIG.container.appid; },
      get tid() { return GLOBAL_CONFIG.container.tid; },
      get rid() { return GLOBAL_CONFIG.container.rid; },
      get bid() { return GLOBAL_CONFIG.container.bid; },
      get instance() { return GLOBAL_CONFIG.container.instance; },
      get projectName() { return GLOBAL_CONFIG.container.projectName; }
    },
    
    // 保存云托管配置信息（从小程序获取的动态配置）
    cloudHostingConfig: null,
    
    // 保存云托管WebSocket连接实例
    containerSocketTask: null,
    
    // 连接状态管理
    connectionState: {
      isConnected: false, // 是否已连接
      connecting: false, // 是否正在连接中
      lastConnectTime: null, // 最后连接时间
      lastDisconnectTime: null, // 最后断开时间
      reconnectAttempts: 0, // 重连尝试次数
      maxReconnectAttempts: 5 // 最大重连尝试次数
    },
    
    // 性能指标记录
    performance: {
      connectionTimes: [], // 连接耗时记录，用于统计平均连接时间
      messageLatency: [] // 消息延迟记录
    }
  },
  
  // 添加方法用于输出当前配置信息
  logConfig: function() {
    console.log('当前配置信息:');
    console.log('配置版本:', this.globalData.version);
    console.log('测试模式:', GLOBAL_CONFIG.environment.testMode);
    console.log('云开发环境ID:', GLOBAL_CONFIG.cloud.env);
    console.log('云托管服务:', GLOBAL_CONFIG.container.service);
    console.log('WebSocket URL:', GLOBAL_CONFIG.websocketUrl);
    console.log('API基础路径:', GLOBAL_CONFIG.apiBaseUrl);
    console.log('cloudConfig.service:', this.globalData.cloudConfig.service);
  }
});